@codex review

Codex Review: Didn't find any major issues. Already looking forward to the next diff.

Reviewed commit: d6c8424884

Thanks @seratch — you're right, the previous_response_id path was still exposed. Pushed a follow-up:

• Auto now falls back to full-history input compaction when the resolved mode would be previous_response_id but the underlying session's default (limit-bounded) view doesn't cover the full stored history. That way the clear+replace can't drop unrepresented items. An explicitly requested previous_response_id compaction is left opt-in and unchanged.
• Detection is a small _underlying_view_covers_history() helper comparing the default get_items() view against the full view; the extra read only happens on the auto + previous_response_id branch.
• Added test_run_compaction_auto_falls_back_to_input_when_history_truncated — a no-force test covering the auto path before replacement (12 candidates over a limit=3 session trigger compaction via the threshold and must send all 12 to responses.compact rather than resolving to previous_response_id).
• Also fixed the typecheck (pyright reportOptionalIterable) failure by guarding the test's input assertions.

Full tests/memory/ suite passes; ruff, mypy, and pyright are clean on the changed files. PTAL.

@seratch ready for another look when you get a chance — the previous_response_id path you flagged now falls back to full-history input compaction whenever the session's limit-bounded view doesn't cover the full stored history, so the clear+replace can't drop unrepresented items. The two follow-up nits since are folded in as well. Thanks!

Thanks @seratch — good catch on the ownership issue. Reworked it so the history window travels with the specific response instead of being inferred from shared get_items() side effects:

• Added input_history_limit to OpenAIResponsesCompactionArgs. save_result_to_session resolves the effective window (session settings + per-run RunConfig) through a shared resolve_session_history_limit helper and passes it alongside the response into both run_compaction and _defer_compaction.
• Removed _last_prepared_input_limit entirely; _underlying_view_covers_history now takes the window as an argument. So the controlled-overlap case (A prepares with limit=3, B with limit=None) can no longer let A read B's limit, and a fresh wrapper on resume — which skips input preparation — still gets the right window because the Runner carries it through save_result_to_session / save_resumed_turn_items (threaded session_settings into those paths).

Added the two regressions you asked for, both asserting the surviving operation compacts from the full stored history:

• test_run_compaction_uses_per_response_limit_under_interleaved_get_items (controlled overlap)
• test_save_result_to_session_carries_run_limit_to_fresh_wrapper_on_resume (fresh wrapper on resume, driven through the Runner save path)

Both fail on the previous commit and pass now. Full tests/memory/ + runner suites pass; ruff, mypy, and pyright are clean. PTAL.

Follow-up: I widened the fix so the per-run window now flows through every save path that can reach compaction, not just the direct save_result_to_session calls. save_turn_items_if_needed (the final-output / run-again paths) and the streaming _save_stream_items / _save_resumed_stream_items closures now thread session_settings too, so a limited run compacts the full stored history on those paths as well.

Added regressions for each: the final-output path (test_save_turn_items_if_needed_carries_run_limit), the deferred-under-limit path (test_deferred_compaction_under_limit_uses_full_history, covering the "into both compaction and deferred compaction" point), and the streaming path (test_save_stream_items_carries_run_limit). Each fails before its threading and passes after. ruff, mypy, and pyright are clean; the full tests/memory/ + runner suites pass. PTAL @seratch.

One more refinement on the efficiency edge: a limited run whose pre-existing history already fit within the window shouldn't be forced onto full-history input just because this turn grows the stored session past the limit — the response genuinely saw everything, so previous_response_id is still safe.

Coverage is now resolved against the pre-save store (the state the response was actually prepared from) in save_result_to_session, and carried as input_covered_full_history rather than recomputed from the post-save session length. The check is a single bounded read that never reports "covered" when it can't prove it, so it stays safe (never drops history) while avoiding the needless oversized input request at the limit boundary. Added test_compaction_reuses_previous_response_id_when_pre_save_history_fits (fails before / passes after). ruff, mypy, and pyright are clean; full tests/memory/ + runner suites pass.

This round is a correctness fix, not just efficiency. When the compaction session wraps a store that carries its own SessionSettings(limit=N) — rather than the wrapper or a RunConfig — resolve_session_history_limit previously saw None (it only read the wrapper's settings) and recorded input_covered_full_history=True, even though get_items(None) delegates to that underlying store and its limit truncates the input. A normal save could then keep previous_response_id and drop the hidden older items.

It now walks the delegate chain (underlying_session) to find the effective limit, so the truncation is detected and compaction falls back to full-history input. Added test_compaction_honors_underlying_session_limit — a save whose limit lives only on the wrapped store must not reuse previous_response_id (fails before / passes after). ruff, mypy, and pyright are clean; the full tests/memory/ + runner suites pass.

Tightened the pre-save coverage check to be exact. It now reads one item beyond the window (get_items(limit + 1)), so a history that exactly fills the limit counts as covered rather than truncated — the earlier len < limit form treated an exact fill as truncated and could force an unnecessary full-history input at the boundary. Since an explicit limit arg wins over a session's own default (resolve_session_limit), get_items(limit + 1) still surfaces a real overflow item, so truncation (including the wrapped-store case) is still detected and it never reports "covered" without proof. Added test_compaction_reuses_previous_response_id_at_exact_limit (fails before / passes after). ruff, mypy, and pyright are clean; the full tests/memory/ + runner suites pass.

@seratch this is ready for another look — consolidating where it landed, since the fixes ended up spread across a few commits.

The ownership blocker is resolved. The history-window state no longer lives in a shared mutable field (_last_prepared_input_limit is gone). save_result_to_session now computes, per response, whether that response's input window covered the full stored history (input_covered_full_history), measured against the pre-save store the response was actually prepared from, and carries that boolean into run_compaction / _defer_compaction. Because it travels with the specific response, interleaved runs and fresh wrappers on resume can no longer read each other's window.

Both regressions you asked for are in:

• test_run_compaction_uses_per_response_limit_under_interleaved_get_items — A prepares with a limit, B with none; asserts A still uses full-history input and the full stored history survives the replace.
• test_save_result_to_session_carries_run_limit_to_fresh_wrapper_on_resume — a fresh wrapper on resume, asserting the per-run limit is honored with no prepare step.

Also hardened along the way: per-run RunConfig(session_settings=…) limits now flow through every save path that reaches compaction (final-output, run-again, streaming); an underlying store's own SessionSettings(limit=N) is honored via the delegate chain; and the pre-save coverage check reads one item beyond the window so an exact-fill window counts as covered rather than being needlessly forced onto input compaction.

Green on the current head: the compaction suite (59 tests) plus ruff, mypy, and pyright clean on the changed files.